Modern applications often host many users at any moment in time wherein the users are simultaneously viewing the applications' data. At any of those moments, these users can actively work on the data within these applications without being aware of one other and the corresponding changes being done by each of them. In an example, multiple users can be working on a certain webpage at some point in time. As the users view this webpage and make changes to it, there will a constant flow of events stemming from each user. However, a potential issue arises wherein the operations coming from these flow of events, which denote the users' changes, become segregated from each other and are not processed in a manner that would allow all of the changes to be properly reflected on the webpage. This is problematic because the webpage now has an incomplete set of changes since it may not be accurately and fully reflecting all of the users' changes in a timely manner. The webpage may reflect some of these changes, but it may be doing so at various different times that can cause the webpage to be out of sync with the users' changes. As a result, invalid data can occur due to this uncoordinated update to the webpage, thus affecting the users' ability to properly work on the webpage since they are working from an invalid data set that can become outdated.
In addition, current applications operate on a push protocol wherein changes are pushed onto the system. This is inefficient because it requires the system to constantly process these changes when it may not have the available resources to do so or even if it does, such resources can be put to better use for another purpose. Indeed, if the system does not have to constantly process these changes, its processing speed and operating efficiency can be greatly increased since it could focus on other pertinent operations. This problem is further magnified when a multitude of applications are being used and operated on because those lost resources get compounded.
Returning to the webpage example above, a push protocol would necessitate a constant push of changes onto the webpage. This can occur when the users are not ready for the changes to be made onto the webpage yet since they desire for their changes to be bundled together in a packet that can then be updated at once during a particular time period. However, under the push protocol, this cannot happen. As such, snippets of these changes are being pushed onto the webpage when it would be more efficient to hold onto them until the user is ready for them to go into effect.
Therefore, another solution is needed that can allow users to request, i.e. pull, the packet of changes for the application at only certain time periods rather than having the packet of changes automatically pushed onto the application and that such a packet be reflective of the changes made by the various users of the application.